/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package dao;

import dao.exceptions.IllegalOrphanException;
import dao.exceptions.NonexistentEntityException;
import dao.exceptions.PreexistingEntityException;
import java.io.Serializable;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import modelo.Usuario;
import modelo.Califica;
import java.util.ArrayList;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import modelo.Evaluador;
import modelo.ExperienciaAcademica;
import modelo.ExperienciaLaboral;

/**
 *
 * @author Fabian
 */
public class EvaluadorJpaController implements Serializable {

    public EvaluadorJpaController(EntityManagerFactory emf) {
        this.emf = emf;
    }
    private EntityManagerFactory emf = null;

    public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

    public void create(Evaluador evaluador) throws IllegalOrphanException, PreexistingEntityException, Exception {
        if (evaluador.getCalificaList() == null) {
            evaluador.setCalificaList(new ArrayList<Califica>());
        }
        if (evaluador.getExperienciaAcademicaList() == null) {
            evaluador.setExperienciaAcademicaList(new ArrayList<ExperienciaAcademica>());
        }
        if (evaluador.getExperienciaLaboralList() == null) {
            evaluador.setExperienciaLaboralList(new ArrayList<ExperienciaLaboral>());
        }
        List<String> illegalOrphanMessages = null;
        Usuario usuarioOrphanCheck = evaluador.getUsuario();
        if (usuarioOrphanCheck != null) {
            Evaluador oldEvaluadorOfUsuario = usuarioOrphanCheck.getEvaluador();
            if (oldEvaluadorOfUsuario != null) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("The Usuario " + usuarioOrphanCheck + " already has an item of type Evaluador whose usuario column cannot be null. Please make another selection for the usuario field.");
            }
        }
        if (illegalOrphanMessages != null) {
            throw new IllegalOrphanException(illegalOrphanMessages);
        }
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Usuario usuario = evaluador.getUsuario();
            if (usuario != null) {
                usuario = em.getReference(usuario.getClass(), usuario.getLogin());
                evaluador.setUsuario(usuario);
            }
            List<Califica> attachedCalificaList = new ArrayList<Califica>();
            for (Califica calificaListCalificaToAttach : evaluador.getCalificaList()) {
                calificaListCalificaToAttach = em.getReference(calificaListCalificaToAttach.getClass(), calificaListCalificaToAttach.getCalificaPK());
                attachedCalificaList.add(calificaListCalificaToAttach);
            }
            evaluador.setCalificaList(attachedCalificaList);
            List<ExperienciaAcademica> attachedExperienciaAcademicaList = new ArrayList<ExperienciaAcademica>();
            for (ExperienciaAcademica experienciaAcademicaListExperienciaAcademicaToAttach : evaluador.getExperienciaAcademicaList()) {
                experienciaAcademicaListExperienciaAcademicaToAttach = em.getReference(experienciaAcademicaListExperienciaAcademicaToAttach.getClass(), experienciaAcademicaListExperienciaAcademicaToAttach.getExperienciaAcademicaPK());
                attachedExperienciaAcademicaList.add(experienciaAcademicaListExperienciaAcademicaToAttach);
            }
            evaluador.setExperienciaAcademicaList(attachedExperienciaAcademicaList);
            List<ExperienciaLaboral> attachedExperienciaLaboralList = new ArrayList<ExperienciaLaboral>();
            for (ExperienciaLaboral experienciaLaboralListExperienciaLaboralToAttach : evaluador.getExperienciaLaboralList()) {
                experienciaLaboralListExperienciaLaboralToAttach = em.getReference(experienciaLaboralListExperienciaLaboralToAttach.getClass(), experienciaLaboralListExperienciaLaboralToAttach.getExperienciaLaboralPK());
                attachedExperienciaLaboralList.add(experienciaLaboralListExperienciaLaboralToAttach);
            }
            evaluador.setExperienciaLaboralList(attachedExperienciaLaboralList);
            em.persist(evaluador);
            if (usuario != null) {
                usuario.setEvaluador(evaluador);
                usuario = em.merge(usuario);
            }
            for (Califica calificaListCalifica : evaluador.getCalificaList()) {
                Evaluador oldEvaluadorOfCalificaListCalifica = calificaListCalifica.getEvaluador();
                calificaListCalifica.setEvaluador(evaluador);
                calificaListCalifica = em.merge(calificaListCalifica);
                if (oldEvaluadorOfCalificaListCalifica != null) {
                    oldEvaluadorOfCalificaListCalifica.getCalificaList().remove(calificaListCalifica);
                    oldEvaluadorOfCalificaListCalifica = em.merge(oldEvaluadorOfCalificaListCalifica);
                }
            }
            for (ExperienciaAcademica experienciaAcademicaListExperienciaAcademica : evaluador.getExperienciaAcademicaList()) {
                Evaluador oldEvaluadorOfExperienciaAcademicaListExperienciaAcademica = experienciaAcademicaListExperienciaAcademica.getEvaluador();
                experienciaAcademicaListExperienciaAcademica.setEvaluador(evaluador);
                experienciaAcademicaListExperienciaAcademica = em.merge(experienciaAcademicaListExperienciaAcademica);
                if (oldEvaluadorOfExperienciaAcademicaListExperienciaAcademica != null) {
                    oldEvaluadorOfExperienciaAcademicaListExperienciaAcademica.getExperienciaAcademicaList().remove(experienciaAcademicaListExperienciaAcademica);
                    oldEvaluadorOfExperienciaAcademicaListExperienciaAcademica = em.merge(oldEvaluadorOfExperienciaAcademicaListExperienciaAcademica);
                }
            }
            for (ExperienciaLaboral experienciaLaboralListExperienciaLaboral : evaluador.getExperienciaLaboralList()) {
                Evaluador oldEvaluadorOfExperienciaLaboralListExperienciaLaboral = experienciaLaboralListExperienciaLaboral.getEvaluador();
                experienciaLaboralListExperienciaLaboral.setEvaluador(evaluador);
                experienciaLaboralListExperienciaLaboral = em.merge(experienciaLaboralListExperienciaLaboral);
                if (oldEvaluadorOfExperienciaLaboralListExperienciaLaboral != null) {
                    oldEvaluadorOfExperienciaLaboralListExperienciaLaboral.getExperienciaLaboralList().remove(experienciaLaboralListExperienciaLaboral);
                    oldEvaluadorOfExperienciaLaboralListExperienciaLaboral = em.merge(oldEvaluadorOfExperienciaLaboralListExperienciaLaboral);
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            if (findEvaluador(evaluador.getCedula()) != null) {
                throw new PreexistingEntityException("Evaluador " + evaluador + " already exists.", ex);
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void edit(Evaluador evaluador) throws IllegalOrphanException, NonexistentEntityException, Exception {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Evaluador persistentEvaluador = em.find(Evaluador.class, evaluador.getCedula());
            Usuario usuarioOld = persistentEvaluador.getUsuario();
            Usuario usuarioNew = evaluador.getUsuario();
            List<Califica> calificaListOld = persistentEvaluador.getCalificaList();
            List<Califica> calificaListNew = evaluador.getCalificaList();
            List<ExperienciaAcademica> experienciaAcademicaListOld = persistentEvaluador.getExperienciaAcademicaList();
            List<ExperienciaAcademica> experienciaAcademicaListNew = evaluador.getExperienciaAcademicaList();
            List<ExperienciaLaboral> experienciaLaboralListOld = persistentEvaluador.getExperienciaLaboralList();
            List<ExperienciaLaboral> experienciaLaboralListNew = evaluador.getExperienciaLaboralList();
            List<String> illegalOrphanMessages = null;
            if (usuarioNew != null && !usuarioNew.equals(usuarioOld)) {
                Evaluador oldEvaluadorOfUsuario = usuarioNew.getEvaluador();
                if (oldEvaluadorOfUsuario != null) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("The Usuario " + usuarioNew + " already has an item of type Evaluador whose usuario column cannot be null. Please make another selection for the usuario field.");
                }
            }
            for (Califica calificaListOldCalifica : calificaListOld) {
                if (!calificaListNew.contains(calificaListOldCalifica)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Califica " + calificaListOldCalifica + " since its evaluador field is not nullable.");
                }
            }
            for (ExperienciaAcademica experienciaAcademicaListOldExperienciaAcademica : experienciaAcademicaListOld) {
                if (!experienciaAcademicaListNew.contains(experienciaAcademicaListOldExperienciaAcademica)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain ExperienciaAcademica " + experienciaAcademicaListOldExperienciaAcademica + " since its evaluador field is not nullable.");
                }
            }
            for (ExperienciaLaboral experienciaLaboralListOldExperienciaLaboral : experienciaLaboralListOld) {
                if (!experienciaLaboralListNew.contains(experienciaLaboralListOldExperienciaLaboral)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain ExperienciaLaboral " + experienciaLaboralListOldExperienciaLaboral + " since its evaluador field is not nullable.");
                }
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            if (usuarioNew != null) {
                usuarioNew = em.getReference(usuarioNew.getClass(), usuarioNew.getLogin());
                evaluador.setUsuario(usuarioNew);
            }
            List<Califica> attachedCalificaListNew = new ArrayList<Califica>();
            for (Califica calificaListNewCalificaToAttach : calificaListNew) {
                calificaListNewCalificaToAttach = em.getReference(calificaListNewCalificaToAttach.getClass(), calificaListNewCalificaToAttach.getCalificaPK());
                attachedCalificaListNew.add(calificaListNewCalificaToAttach);
            }
            calificaListNew = attachedCalificaListNew;
            evaluador.setCalificaList(calificaListNew);
            List<ExperienciaAcademica> attachedExperienciaAcademicaListNew = new ArrayList<ExperienciaAcademica>();
            for (ExperienciaAcademica experienciaAcademicaListNewExperienciaAcademicaToAttach : experienciaAcademicaListNew) {
                experienciaAcademicaListNewExperienciaAcademicaToAttach = em.getReference(experienciaAcademicaListNewExperienciaAcademicaToAttach.getClass(), experienciaAcademicaListNewExperienciaAcademicaToAttach.getExperienciaAcademicaPK());
                attachedExperienciaAcademicaListNew.add(experienciaAcademicaListNewExperienciaAcademicaToAttach);
            }
            experienciaAcademicaListNew = attachedExperienciaAcademicaListNew;
            evaluador.setExperienciaAcademicaList(experienciaAcademicaListNew);
            List<ExperienciaLaboral> attachedExperienciaLaboralListNew = new ArrayList<ExperienciaLaboral>();
            for (ExperienciaLaboral experienciaLaboralListNewExperienciaLaboralToAttach : experienciaLaboralListNew) {
                experienciaLaboralListNewExperienciaLaboralToAttach = em.getReference(experienciaLaboralListNewExperienciaLaboralToAttach.getClass(), experienciaLaboralListNewExperienciaLaboralToAttach.getExperienciaLaboralPK());
                attachedExperienciaLaboralListNew.add(experienciaLaboralListNewExperienciaLaboralToAttach);
            }
            experienciaLaboralListNew = attachedExperienciaLaboralListNew;
            evaluador.setExperienciaLaboralList(experienciaLaboralListNew);
            evaluador = em.merge(evaluador);
            if (usuarioOld != null && !usuarioOld.equals(usuarioNew)) {
                usuarioOld.setEvaluador(null);
                usuarioOld = em.merge(usuarioOld);
            }
            if (usuarioNew != null && !usuarioNew.equals(usuarioOld)) {
                usuarioNew.setEvaluador(evaluador);
                usuarioNew = em.merge(usuarioNew);
            }
            for (Califica calificaListNewCalifica : calificaListNew) {
                if (!calificaListOld.contains(calificaListNewCalifica)) {
                    Evaluador oldEvaluadorOfCalificaListNewCalifica = calificaListNewCalifica.getEvaluador();
                    calificaListNewCalifica.setEvaluador(evaluador);
                    calificaListNewCalifica = em.merge(calificaListNewCalifica);
                    if (oldEvaluadorOfCalificaListNewCalifica != null && !oldEvaluadorOfCalificaListNewCalifica.equals(evaluador)) {
                        oldEvaluadorOfCalificaListNewCalifica.getCalificaList().remove(calificaListNewCalifica);
                        oldEvaluadorOfCalificaListNewCalifica = em.merge(oldEvaluadorOfCalificaListNewCalifica);
                    }
                }
            }
            for (ExperienciaAcademica experienciaAcademicaListNewExperienciaAcademica : experienciaAcademicaListNew) {
                if (!experienciaAcademicaListOld.contains(experienciaAcademicaListNewExperienciaAcademica)) {
                    Evaluador oldEvaluadorOfExperienciaAcademicaListNewExperienciaAcademica = experienciaAcademicaListNewExperienciaAcademica.getEvaluador();
                    experienciaAcademicaListNewExperienciaAcademica.setEvaluador(evaluador);
                    experienciaAcademicaListNewExperienciaAcademica = em.merge(experienciaAcademicaListNewExperienciaAcademica);
                    if (oldEvaluadorOfExperienciaAcademicaListNewExperienciaAcademica != null && !oldEvaluadorOfExperienciaAcademicaListNewExperienciaAcademica.equals(evaluador)) {
                        oldEvaluadorOfExperienciaAcademicaListNewExperienciaAcademica.getExperienciaAcademicaList().remove(experienciaAcademicaListNewExperienciaAcademica);
                        oldEvaluadorOfExperienciaAcademicaListNewExperienciaAcademica = em.merge(oldEvaluadorOfExperienciaAcademicaListNewExperienciaAcademica);
                    }
                }
            }
            for (ExperienciaLaboral experienciaLaboralListNewExperienciaLaboral : experienciaLaboralListNew) {
                if (!experienciaLaboralListOld.contains(experienciaLaboralListNewExperienciaLaboral)) {
                    Evaluador oldEvaluadorOfExperienciaLaboralListNewExperienciaLaboral = experienciaLaboralListNewExperienciaLaboral.getEvaluador();
                    experienciaLaboralListNewExperienciaLaboral.setEvaluador(evaluador);
                    experienciaLaboralListNewExperienciaLaboral = em.merge(experienciaLaboralListNewExperienciaLaboral);
                    if (oldEvaluadorOfExperienciaLaboralListNewExperienciaLaboral != null && !oldEvaluadorOfExperienciaLaboralListNewExperienciaLaboral.equals(evaluador)) {
                        oldEvaluadorOfExperienciaLaboralListNewExperienciaLaboral.getExperienciaLaboralList().remove(experienciaLaboralListNewExperienciaLaboral);
                        oldEvaluadorOfExperienciaLaboralListNewExperienciaLaboral = em.merge(oldEvaluadorOfExperienciaLaboralListNewExperienciaLaboral);
                    }
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                String id = evaluador.getCedula();
                if (findEvaluador(id) == null) {
                    throw new NonexistentEntityException("The evaluador with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void destroy(String id) throws IllegalOrphanException, NonexistentEntityException {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Evaluador evaluador;
            try {
                evaluador = em.getReference(Evaluador.class, id);
                evaluador.getCedula();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("The evaluador with id " + id + " no longer exists.", enfe);
            }
            List<String> illegalOrphanMessages = null;
            List<Califica> calificaListOrphanCheck = evaluador.getCalificaList();
            for (Califica calificaListOrphanCheckCalifica : calificaListOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Evaluador (" + evaluador + ") cannot be destroyed since the Califica " + calificaListOrphanCheckCalifica + " in its calificaList field has a non-nullable evaluador field.");
            }
            List<ExperienciaAcademica> experienciaAcademicaListOrphanCheck = evaluador.getExperienciaAcademicaList();
            for (ExperienciaAcademica experienciaAcademicaListOrphanCheckExperienciaAcademica : experienciaAcademicaListOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Evaluador (" + evaluador + ") cannot be destroyed since the ExperienciaAcademica " + experienciaAcademicaListOrphanCheckExperienciaAcademica + " in its experienciaAcademicaList field has a non-nullable evaluador field.");
            }
            List<ExperienciaLaboral> experienciaLaboralListOrphanCheck = evaluador.getExperienciaLaboralList();
            for (ExperienciaLaboral experienciaLaboralListOrphanCheckExperienciaLaboral : experienciaLaboralListOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Evaluador (" + evaluador + ") cannot be destroyed since the ExperienciaLaboral " + experienciaLaboralListOrphanCheckExperienciaLaboral + " in its experienciaLaboralList field has a non-nullable evaluador field.");
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            Usuario usuario = evaluador.getUsuario();
            if (usuario != null) {
                usuario.setEvaluador(null);
                usuario = em.merge(usuario);
            }
            em.remove(evaluador);
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public List<Evaluador> findEvaluadorEntities() {
        return findEvaluadorEntities(true, -1, -1);
    }

    public List<Evaluador> findEvaluadorEntities(int maxResults, int firstResult) {
        return findEvaluadorEntities(false, maxResults, firstResult);
    }

    private List<Evaluador> findEvaluadorEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            cq.select(cq.from(Evaluador.class));
            Query q = em.createQuery(cq);
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    public Evaluador findEvaluador(String id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(Evaluador.class, id);
        } finally {
            em.close();
        }
    }

    public int getEvaluadorCount() {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            Root<Evaluador> rt = cq.from(Evaluador.class);
            cq.select(em.getCriteriaBuilder().count(rt));
            Query q = em.createQuery(cq);
            return ((Long) q.getSingleResult()).intValue();
        } finally {
            em.close();
        }
    }
    
}
